package com.loong.android.tools;

import java.math.BigDecimal;

/**
 * 算数工具类
 */
public class Math {

    public final static double PI = java.lang.Math.PI;

    /**
     * 取绝对值
     * @param val 数值
     */
    public static byte abs(byte val) {
        return (byte) java.lang.Math.abs((int) val);
    }

    /**
     * 取绝对值
     * @param val 数值
     */
    public static short abs(short val) {
        return (short) java.lang.Math.abs((int) val);
    }

    /**
     * 取绝对值
     * @param val 数值
     */
    public static int abs(int val) {
        return java.lang.Math.abs(val);
    }

    /**
     * 取绝对值
     * @param val 数值
     */
    public static long abs(long val) {
        return java.lang.Math.abs(val);
    }

    /**
     * 取绝对值
     * @param val 数值
     */
    public static float abs(float val) {
        return java.lang.Math.abs(val);
    }

    /**
     * 取绝对值
     * @param val 数值
     */
    public static double abs(double val) {
        return java.lang.Math.abs(val);
    }

    /**
     * 取反向值
     * @param val 值
     */
    public static boolean reverse(boolean val) {
        return !val;
    }

    /**
     * 小数型(float)强转为整数型(int)
     * @param val 值
     */
    public static int toInteger(float val) {
        return (int) val;
    }

    /**
     * 长小数型(double)强转为整数型(int)
     * @param val 值
     */
    public static int toInteger(double val) {
        return (int) val;
    }

    /**
     * 小数型(float)强转为短整数型(short)
     * @param val 值
     */
    public static short toShort(float val) {
        return (short) val;
    }

    /**
     * 长小数型(double)强转为短整数型(short)
     * @param val 值
     */
    public static short toShort(double val) {
        return (short) val;
    }

    /**
     * 小数型(float)强转为长整数型(long)
     * @param val 值
     */
    public static long toLong(float val) {
        return (long) val;
    }

    /**
     * 长小数型(double)强转为长整数型(long)
     * @param val 值
     */
    public static long toLong(double val) {
        return (long) val;
    }

    /**
     * 求正弦
     * @param val 值
     */
    public static double sin(double val) {
        return java.lang.Math.sin(val);
    }

    /**
     * 求反正弦
     * @param val 值
     */
    public static double asin(double val) {
        return java.lang.Math.asin(val);
    }

    /**
     * 求双曲正弦
     * @param val 值
     */
    public static double sinh(double val) {
        return java.lang.Math.sinh(val);
    }

    /**
     * 求余弦
     * @param val 值
     */
    public static double cos(double val) {
        return java.lang.Math.cos(val);
    }

    /**
     * 求反余弦
     * @param val 值
     */
    public static double acos(double val) {
        return java.lang.Math.acos(val);
    }

    /**
     * 求双曲余弦
     * @param val 值
     */
    public static double cosh(double val) {
        return java.lang.Math.cosh(val);
    }

    /**
     * 求正切
     * @param val 值
     */
    public static double tan(double val) {
        return java.lang.Math.tan(val);
    }

    /**
     * 求反正切
     * @param val 值
     */
    public static double atan(double val) {
        return java.lang.Math.atan(val);
    }

    /**
     * 求双曲正切
     * @param val 值
     */
    public static double tanh(double val) {
        return java.lang.Math.tanh(val);
    }

    /**
     * 取最大值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static byte max(byte val1, byte val2) {
        return (byte) java.lang.Math.max((int) val1, (int) val2);
    }

    /**
     * 取最大值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static short max(short val1, short val2) {
        return (short) java.lang.Math.max((int) val1, (int) val2);
    }

    /**
     * 取最大值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static int max(int val1, int val2) {
        return java.lang.Math.max(val1, val2);
    }

    /**
     * 取最大值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static long max(long val1, long val2) {
        return java.lang.Math.max(val1, val2);
    }

    /**
     * 取最大值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static float max(float val1, float val2) {
        return java.lang.Math.max(val1, val2);
    }

    /**
     * 取最大值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static double max(double val1, double val2) {
        return java.lang.Math.max(val1, val2);
    }

    /**
     * 取最小值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static byte min(byte val1, byte val2) {
        return (byte) java.lang.Math.min((int) val1, (int) val2);
    }

    /**
     * 取最小值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static short min(short val1, short val2) {
        return (short) java.lang.Math.min((int) val1, (int) val2);
    }

    /**
     * 取最小值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static int min(int val1, int val2) {
        return java.lang.Math.min(val1, val2);
    }

    /**
     * 取最小值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static long min(long val1, long val2) {
        return java.lang.Math.min(val1, val2);
    }

    /**
     * 取最小值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static float min(float val1, float val2) {
        return java.lang.Math.min(val1, val2);
    }

    /**
     * 取最小值
     * @param val1 数值1
     * @param val2 数值2
     */
    public static double min(double val1, double val2) {
        return java.lang.Math.min(val1, val2);
    }

    /**
     * 取随机数，取值范围>=min, <=max
     * @param min 最小值
     * @param max 最大值
     */
    public static int random(int min, int max) {
        if (max < min) return 0;
        return min + (int) (java.lang.Math.random() * (max - min + 1));
    }

    /**
     * 弧度转角度
     * @param radian 弧度
     */
    public static double toDegrees(double radian) {
        return java.lang.Math.toDegrees(radian);
    }

    /**
     * 角度转弧度
     * @param degree 角度
     */
    public static double toRadians(double degree) {
        return java.lang.Math.toRadians(degree);
    }

    /**
     * 向上取整，返回不小于它的整数。如: 5.8 => 6.0; -2.5 => -2.0
     * @param val 值
     */
    public static long ceil(double val) {
        return (long) java.lang.Math.ceil(val);
    }

    /**
     * 向下取整，返回不大于它的整数。如: 5.8 => 5.0; -2.5 => -3.0
     * @param val
     * @return
     */
    public static long floor(double val) {
        return (long) java.lang.Math.floor(val);
    }

    /**
     * 四舍五入
     * @param val 数值
     * @param decimal 保留的小数位数。如保留2位小数，5.125 => 5.13
     */
    public static double round(double val, int decimal) {
        BigDecimal bigDecimal = BigDecimal.valueOf(val);
        return bigDecimal.setScale(decimal, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 四舍五入
     * @param val 数值
     * @param decimal 保留的小数位数。如保留2位小数，5.125 => 5.13
     */
    public static float round(float val, int decimal) {
        BigDecimal bigDecimal = BigDecimal.valueOf(val);
        return bigDecimal.setScale(decimal, BigDecimal.ROUND_HALF_UP).floatValue();
    }

    /**
     * 求平方: x²
     * @param val 数值
     */
    public static double pow2(double val) {
        return java.lang.Math.pow(val, 2);
    }

    /**
     * 求次方: x³
     * @param val 数值
     */
    public static double pow3(double val) {
        return java.lang.Math.pow(val, 3);
    }

    /**
     * 求数值的n次幂: xⁿ
     * @param val 数值
     * @param pow 次幂
     */
    public static double pow(double val, double pow) {
        return java.lang.Math.pow(val, pow);
    }

    /**
     * 求平方根
     * @param val 数值
     */
    public static double sqrt(double val) {
        return java.lang.Math.sqrt(val);
    }

    /**
     * 求立方根
     * @param val 数值
     */
    public static double cbrt(double val) {
        return java.lang.Math.cbrt(val);
    }

    /**
     * 求E次幂
     * @param val 次幂
     */
    public static double exp(double val) {
        return java.lang.Math.exp(val);
    }

    /**
     * 求自然对数
     * @param val 数值
     */
    public static double log(double val) {
        return java.lang.Math.log(val);
    }

    /**
     * 求余数
     * @param val1 被除数
     * @param val2 除数
     */
    public static double remainder(double val1, double val2) {
        return java.lang.Math.IEEEremainder(val1, val2);
    }
}
